package com.sdgakj.service.login;

import com.alibaba.fastjson.JSONObject;
import com.sdgakj.entity.Family;
import com.sdgakj.entity.Person;
import com.sdgakj.entity.ShtCity;
import com.sdgakj.entity.User;
import com.sdgakj.enums.EnumIsDelete;
import com.sdgakj.enums.EnumSMSType;
import com.sdgakj.enums.EnumUserType;
import com.sdgakj.service.ServiceException;
import com.sdgakj.service.account.AccountService;
import com.sdgakj.service.person.PersonService;
import com.sdgakj.service.user.UserService;
import com.sdgakj.utils.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.MessageFormat;
import java.util.*;


@Component
public class UserLoginService {

    public static final String HASH_ALGORITHM = "SHA-1";
    public static final String OUMAN_CHECKNUM = "OUMAN-20160927";
    public static final int HASH_INTERATIONS = 1024;

    private static Logger logger = LoggerFactory.getLogger(UserLoginService.class);

    @Autowired
    private UserService userService;

    @Autowired
    private AccountService accountService;

    @Autowired
    private PersonService personService;
    /**
     * 用户登录
     *
     * @param tell
     * @param curPwd
     * @return
     */
    public String login(String tell, String curPwd) {
        User user = userService.getUserByTell(tell, EnumUserType.CUSTOMOR.getCode());
        if (user == null) {
            user = userService.getUserByLoginName(tell);
        }
        JSONObject json = new JSONObject();
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("tel", tell);
        json.put("repBody", map);
        if (user != null) {
            String pwd = user.getPassword();  // 数据库中的加密密码
            String inputpwd = accountService.getEntryptPassword(curPwd, user.getSalt()); // 加密后的密码
            if (pwd.equals(inputpwd)) {
                // 如果密码一致则可登录
                map.put("id", user.getId());
                map.put("name", user.getName());
                map.put("loginName", user.getLoginName());
                map.put("mobile",user.getMobile());
                Person person= personService.getPersonByUserId(user.getId());
                if(person!=null){
                    map.put("personId",person.getId());
                }
//              map.put("type", user.getType());
                // 如果是user用户，意味着是普通用户,则需再次查询一次
                json.put("resCode", "1");
                json.put("resMsg", "登录成功");
            } else {
                json.put("resCode", "0");
                json.put("resMsg", "用户密码错误");
            }
        } else {
            json.put("resCode", "0");
            json.put("resMsg", "用户账号不存在");
        }
        return json.toJSONString();
    }


    /**
     * 给用户手机号发送验证码
     *
     * @param tel
     * @return
     */
    public String sendValidateSmsCode(String tel) {

        JSONObject json = new JSONObject();

        Random random = new Random();
        String sRand = "";
        for (int i = 0; i < 4; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand += rand;
        }
        String content = "您的校验码是：" + sRand + "。请不要把校验码泄露给其他人。如非本人操作，可不用理会！（校验码半小时内有效）";

        try {
            RedisClient.cacheAdd(tel.concat("_code"), sRand, 30 * 60);
        } catch (Exception e) {
            logger.error("redis error:" + e.getMessage());
        }

        // 发送短信
        String result = "";
        /**2016年2月26日09:38:06 v2.0*/
//      producer.sendMessage(destination, tel,content,EnumSMSType.SECURITY_CODE.getCode());

//      String result = SMSSender.sendSms(tel, content, EnumSMSType.SECURITY_CODE);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("tel", tel);
        json.put("data", map);
        /**原版代码*/
//      if (result != null && result.indexOf("<code>2") > -1) { //判断返回码是否为2，2是成功
//          json.put("resCode", "1");
//          json.put("resMsg", "发送短信成功");
//          logger.info("tel:"+tel,"date:"+new Date());
//      } else {
//          json.put("resCode", "0");
//          json.put("resMsg", "发送短信失败");
//          if(result.indexOf("<code>408") > -1){
//              json.put("resCode", "0");
//              json.put("resMsg", "您的手机号当天发送验证码过多，请稍后再试");
//          }               
//      }

        /**2016年2月26日09:37:24  v2.0*/
        json.put("resCode", "1");
        json.put("resMsg", "发送短信成功");
        return json.toJSONString();
    }

    /**
     * 阿里大鱼调用的方法
     *
     * @param tel
     * @return
     */
    public String sendSmsCode(String tel) {
        JSONObject json = new JSONObject();

        Random random = new Random();
        String sRand = "";
        for (int i = 0; i < 4; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand += rand;
        }
        try {
            RedisClient.cacheAdd(tel.concat("_code"), sRand, 30 * 60);
        } catch (Exception e) {
            logger.error("redis error:" + e.getMessage());
        }
        // 一天内，同一手机号仅允许发送5条短信
        Object times = RedisClient
                .cacheGet(tel.concat("_code_times_").concat(DateUtil.formatDateToString(new Date(), "yyyyMMdd")));
        if (times != null && Integer.valueOf(times.toString()) >= 20) {
            logger.info("单一号码短信条数超限------------->:" + tel);
            throw new ServiceException("您今天已达验证码发送上限");
        }

        User user = userService.getUserByLoginName(tel, EnumUserType.CUSTOMOR.getCode());

        String flag = user == null ? "1" : "0";

        SMSDYSender.sendSms(tel, sRand);
//      producer.sendMessage(destination, tel, sRand, EnumSMSType.SECURITY_CODE.getCode());
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("tel", tel);
        map.put("isnew", flag);
        json.put("data", map);
        json.put("resCode", "1");
        json.put("resMsg", "发送短信成功");
        // json.put("code", sRand);
        return json.toJSONString();
    }

    /**
     * 根据电话和验证码给用户发送
     *
     * @param tel
     *         手机号
     * @param code
     *         验证码
     * @return
     */
    public String sendCode(String tel, String code) {
        try {
            RedisClient.cacheAdd(tel.concat("_code"), code, 30 * 60);
            String content = "您的校验码是：" + code + "。请不要把校验码泄露给其他人。如非本人操作，可不用理会！（校验码半小时内有效）";
            String result = SMSSender.sendSms(tel, content, EnumSMSType.SECURITY_CODE);
            if (result != null && result.indexOf("<code>2") > -1) { //判断返回码是否为2，2是成功
                return "1";
            } else {
                return "2";  //如果因为短信通道的某些原因发送失败都默认为2
            }
        } catch (Exception e) {
            return "0";
        }
    }

    /**
     * 给检测师发送密码
     *
     * @param tel
     * @return
     */
    public String sendPwdCode(String tel, String pwd) {

        JSONObject json = new JSONObject();
        String content = "恭喜您，已成功注册蜗牛检测用户！用户名为您接收短信的手机号码，密码为" + pwd + "。为了您的账号安全，请尽快登录并修改密码！";
        ;
        try {
            // 发送短信
            String result = SMSPwdSender.sendPwd(tel, content, EnumSMSType.SECURITY_CODE);
            if (result != null && result.indexOf("<code>2") > -1) { //判断返回码是否为2，2是成功
                logger.info("检测师：" + tel + "的密码已成功发送");
            }
        } catch (Exception e) {
            logger.error("检测师:" + tel + "的密码没有发送成功，因为" + e.getMessage());
        }

        return json.toJSONString();
    }

    /**
     * 用户注册
     *
     * @param tell
     *         电话号码
     * @param pwd
     *         密码
     * @param insertCode
     *         接收的验证码
     * @return
     */
    public String register(String tell, String pwd, String insertCode) {
        JSONObject json = new JSONObject();
        boolean flag = MyUtils.checkMobile(tell);
        if (!flag) {
            json.put("resCode", "0");
            json.put("resMsg", "请输入正确的手机号");
            return json.toJSONString();
        }
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tell);

            json.put("resCode", "1");
            json.put("resMsg", "注册成功");
            User user = userService.getUserByTell(tell, EnumUserType.CUSTOMOR.getCode()); //根据tell和role查询用户是否注册

            //如果用户存在并且不是匿名--手机号已存在
            if (user != null) { //&& user.getDeltag()!=EnumIsDelete.DELETED.getCode()这里需要判断是否删除吗？
                json.put("resCode", "0");
                json.put("resMsg", "手机号已存在");
                return json.toJSONString();
            }

            // 验证手机验证码
            if (!checkValidateCode(tell, insertCode)) {
                json.put("resCode", "0");
                json.put("resMsg", "验证码错误！");
                return json.toJSONString();
            }
            json.put("data", map);
            if (json.get("resCode").equals("1")) {
                if (user == null) {
                    User newUser = new User();
                    newUser.setLoginName(tell);
                    newUser.setName(tell);
                    newUser.setPassword(pwd);
                    newUser.setPlainPassword(pwd);
                    newUser.setMobile(tell);
                    newUser.setIntegration(100);
                    newUser.setShtCity(new ShtCity(1));
                    newUser.setDeltag(EnumIsDelete.NOTDELETE.getCode());  // 默认是未删除
                    accountService.entryptPassword(newUser);
                    newUser.setType(EnumUserType.CUSTOMOR.getCode());  //标记是普通的用户类
                    Long id=userService.saveUser(newUser);
                    //向person增加一名用户
                    Person person=new Person();
                    person.setCreatetime(new Date());
                    person.setUpdatetime(new Date());
                    person.setName(tell);
                    person.setM(0L);
                    person.setF(0L);
                    person.setVir(0L);
                    person.setUx(0L);
                    person.setMobile(tell);
                    Family family=new Family();
                    family.setId(0L);
                    person.setUser(newUser);
                    personService.savePerson(person);
                    person=personService.getPersonByUserId(id);
                    newUser=userService.getUserById(id);
                    newUser.setPerson(person);
                    userService.updateUser(newUser);
//                    List<ShtCity> citys = areaService.getCityByLikeName(cname);
//                    if (!CollectionUtils.isEmpty(citys)) {
//                        customor.setShtCity(citys.get(0));
//                        customor.setShtProvince(citys.get(0).getProvince());
//                    }
//                    // 创建用户做任务统计数
//                    List<CustomerTask> customerTasks = customerTaskService.getAllList();
//                    for (CustomerTask customerTask : customerTasks) {
//                        CustomerTaskActive entity = new CustomerTaskActive();
//                        entity.setCustomerInfo(customor);
//                        entity.setCustomerTaskInfo(customerTask);
//                        entity.setDay(DateUtil.formatDateToString(new Date(), "yyyy-MM-dd"));
//                        entity.setCreatetime(new Date());
//                        entity.setCount(0);
//                        customerTaskActiveService.saveCustomerTaskActive(entity);
//                    }
//                    // 邀请用户加积分
//                    if (null != lcustomer) {
//                        customerTaskActiveService.saveIntegration(customor.getId(), EnumTaskType.RECOMMEND.getCode());
//                    }
                    json.put("data", map);
                    json.put("resCode", "1");
                    json.put("resMsg", "注册成功");
                    /**插入设备号*/
                    // 设备号移动到user实体中
/*                    if(!deviceno.equals("0")){                          
                        new InsertDeviceThread(deviceno,tell).run();
                    }*/

                }
            }
//          }
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("regist user is error :" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * @param mobile
     *         手机号码
     * @param code
     *         验证码
     * @param cname
     *         定位城市名称
     * @param invitecode
     *         邀请码
     * @param iscoming
     *         来源
     * @return
     */
    public JSONObject loginByMobileWithCode(String mobile, String code, String cname, String invitecode, String iscoming, String deviceno) {

        JSONObject json = new JSONObject();


        boolean flag = MyUtils.checkMobile(mobile);
        if (!flag) {
            json.put("resCode", "0");
            json.put("resMsg", "请输入正确的手机号");
            return json;
        }

        // 验证手机验证码
        if (!checkValidateCode(mobile, code)) {
            json.put("resCode", "0");
            json.put("resMsg", "验证码错误！");
            return json;
        }


        Map<String, Object> map = new HashMap<>();
        try {
            User user = userService.getUserByTell(mobile, EnumUserType.CUSTOMOR.getCode()); //根据tell和role查询用户是否注册

            //如果用户存在返回相关信息
            if (user != null) {

//              map.put("type", user.getType());
                json.put("data", map);
                json.put("resCode", "1");
                json.put("resMsg", "登录成功!");
            } else {
                // 不存在则注册一个账户
                User newUser = new User();
                newUser.setLoginName(mobile);
                newUser.setName(mobile);
                newUser.setPassword("0");
                newUser.setPlainPassword("0");
                newUser.setMobile(mobile);
                newUser.setDeltag(EnumIsDelete.NOTDELETE.getCode());  // 默认是未删除
                accountService.entryptPassword(newUser);
                newUser.setType(EnumUserType.CUSTOMOR.getCode());  //标记是普通的用户类
                json.put("data", map);
                json.put("resCode", "1");
                json.put("resMsg", "登录成功!");

            }

        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "登录失败,请重试！");
            logger.error("regist user is error :" + e.getMessage());
        }
        return json;
    }


    /**
     * 欧曼用户注册
     *
     * @param tell
     *         电话号码
     * @param pwd
     *         密码
     *         接收的验证码
     * @return
     */
    public String register(String tell, String pwd, String checkNum, String cname, String iscoming) {
        JSONObject json = new JSONObject();
        boolean flag = MyUtils.checkMobile(tell);
        if (!flag) {
            json.put("resCode", "0");
            json.put("resMsg", "请输入正确的手机号");
            return json.toJSONString();
        }
        if (!OUMAN_CHECKNUM.equals(checkNum)) {
            json.put("resCode", "0");
            json.put("resMsg", "请输入正确的验证数字");
            return json.toJSONString();
        }
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tell);
            User user = userService.getUserByTell(tell, EnumUserType.CUSTOMOR.getCode()); // 根据tell和role查询用户是否注册

            json.put("resCode", "1");
            json.put("resMsg", "注册成功");

            // 如果用户存在并且不是匿名--手机号已存在
            if (user != null) { // &&
                // user.getDeltag()!=EnumIsDelete.DELETED.getCode()这里需要判断是否删除吗？
                json.put("resCode", "0");
                json.put("resMsg", "手机号已存在");
                return json.toJSONString();
            }

            json.put("data", map);
            if (json.get("resCode").equals("1")) {
                if (user == null) {
                    User newUser = new User();
                    newUser.setLoginName(tell);
                    newUser.setName(tell);
                    newUser.setPassword(pwd);
                    newUser.setPlainPassword(pwd);
                    newUser.setMobile(tell);
                    newUser.setDeltag(EnumIsDelete.NOTDELETE.getCode()); // 默认是未删除
                    accountService.entryptPassword(newUser);
                    newUser.setType(EnumUserType.CUSTOMOR.getCode()); // 标记是普通的用户类
                    json.put("data", map);
                    json.put("resCode", "1");
                    json.put("resMsg", "注册成功");
                }
            }
            // }
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("regist user is error :" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * 后台给用户注册
     *
     * @param tell
     *         电话号码
     * @param pwd
     *         密码
     * @return
     */
    public String registByAdmin(String tell, String pwd) {
        String flag = "1";
        try {
            User user = userService.getUserByTell(tell, EnumUserType.CUSTOMOR.getCode()); //根据tell和role查询用户是否注册
            //如果用户存在并且不是匿名--手机号已存在
            if (user != null) { //&& user.getDeltag()!=EnumIsDelete.DELETED.getCode()这里需要判断是否删除吗？
                return "0";
            }
            if (flag.equals("1")) {
                if (user == null) {
                    User newUser = new User();
                    newUser.setLoginName(tell);
                    newUser.setName(tell);
                    newUser.setPassword(pwd);
                    newUser.setPlainPassword(pwd);
                    newUser.setMobile(tell);
                    newUser.setDeltag(EnumIsDelete.NOTDELETE.getCode());  // 默认是未删除
                    accountService.entryptPassword(newUser);
                    newUser.setType(EnumUserType.CUSTOMOR.getCode());  //标记是普通的用户类

                }
            }
//          }
        } catch (ServiceException e) {
            logger.error("regist user is error :" + e.getMessage());
        }
        return flag;
    }

    /**
     * 无账号注册登录
     *
     * @param tell
     *         手机号码
     * @param insertCode
     *         验证码
     * @return
     */
    public String loginByNoAccount(String tell, String insertCode) {
        JSONObject json = new JSONObject();
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tell);
            // 验证手机验证码
            if (!checkValidateCode(tell, insertCode)) {
                json.put("resCode", "0");
                json.put("resMsg", "验证码错误！");
            } else { // 验证码正确的话，再判断是否存在
                // 如果用户存在，则取出来，json为登录
            }
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
        }
        return json.toJSONString();
    }

    /**
     * 重置密码
     *
     * @param mobile
     * @param pwd
     * @param code
     * @return
     */
    public String recoverPwd(String mobile, String pwd, String code) {
        JSONObject json = new JSONObject();
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", mobile);
            User user = userService.getUserByTell(mobile, EnumUserType.CUSTOMOR.getCode());
            json.put("resCode", "1");
            json.put("resMsg", "重置密码成功");
            if (user == null) {
                json.put("resCode", "0");
                json.put("resMsg", "用户账号不存在");
                return json.toJSONString();
            }

            // 验证手机验证码
            if (!checkValidateCode(mobile, code)) {
                json.put("resCode", "0");
                json.put("resMsg", "验证码错误！");
                return json.toJSONString();
            }
            json.put("data", map);

            // 用户更新
            user.setMobile(mobile);
            user.setPlainPassword(pwd);
            accountService.entryptPassword(user);
            userService.updateUser(user);
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("重置用户密码失败：" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * 重置密码
     *
     * @param tell
     * @param pwd
     * @return
     */
    public String oumanRecoverPwd(String tell, String pwd, String checkNum) {
        JSONObject json = new JSONObject();
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tell);
            User user = userService.getUserByTell(tell, EnumUserType.CUSTOMOR.getCode());
            json.put("resCode", "1");
            json.put("resMsg", "重置密码成功");
            if (user == null) {
                json.put("resCode", "0");
                json.put("resMsg", "用户账号不存在");
                return json.toJSONString();
            }

            // 验证手机验证码
            if (!OUMAN_CHECKNUM.equals(checkNum)) {
                json.put("resCode", "0");
                json.put("resMsg", "验证码错误！");
                return json.toJSONString();
            }
            json.put("data", map);

            // 用户更新
            user.setMobile(tell);
            user.setPlainPassword(pwd);
            accountService.entryptPassword(user);
            userService.updateUser(user);
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("重置用户密码失败：" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * 欧曼修改密码
     *
     * @param pwd
     * @param newPwd
     * @return
     */
    public String changePwd(String tel, String pwd, String newPwd, String checkNum) {
        JSONObject json = new JSONObject();
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tel);
            User user = userService.getUserByTell(tel, EnumUserType.CUSTOMOR.getCode());
            json.put("resCode", "1");
            json.put("resMsg", "修改密码成功");
            String oldPwd = "";
            String inputpwd = "";
            if (!OUMAN_CHECKNUM.equals(checkNum)) {
                json.put("resCode", "0");
                json.put("resMsg", "验证码错误");
                return json.toJSONString();
            }
            if (user == null) {
                json.put("resCode", "0");
                json.put("resMsg", "用户账号不存在");
                return json.toJSONString();
            } else {
                oldPwd = user.getPassword(); // 数据库的密码
                // inputpwd = Md5Util.toMD5(pwd); // 对输入的原密码加密
                inputpwd = accountService.getEntryptPassword(pwd, user.getSalt());// 根据输入的原密码和数据库的盐，反推加密后的密码
                // 验证两个密码是否一致
                if (!oldPwd.equals(inputpwd)) {
                    json.put("resCode", "0");
                    json.put("resMsg", "原密码错误！");
                    return json.toJSONString();
                } else { // 两个密码一致，就可以更新密码
                    user.setPlainPassword(newPwd);
                    user.setPassword(newPwd);
                    accountService.entryptPassword(user); // 对密码进行加密
                    // user.setPwd(Md5Util.toMD5(newPwd));
                    userService.updateUser(user);
                }
            }
            json.put("data", map);

            // // 修改密码
            // if (json.get("resCode").equals("1")) {
            // user.setPlainPassword(newPwd);
            // accountService.entryptPassword(user); //对密码进行加密
            // //user.setPwd(Md5Util.toMD5(newPwd));
            // userService.updateUser(user);
            // }
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("修改密码失败，错误为：" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * 修改密码
     *
     * @param pwd
     * @param newPwd
     * @return
     */
    public String changePwd(String tel, String pwd, String newPwd) {
        JSONObject json = new JSONObject();
        try {
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("tel", tel);
            User user = userService.getUserByTell(tel, EnumUserType.CUSTOMOR.getCode());
            json.put("resCode", "1");
            json.put("resMsg", "修改密码成功");
            String oldPwd = "";
            String inputpwd = "";
            if (user == null) {
                json.put("resCode", "0");
                json.put("resMsg", "用户账号不存在");
                return json.toJSONString();
            } else {
                oldPwd = user.getPassword(); // 数据库的密码
                //inputpwd = Md5Util.toMD5(pwd); // 对输入的原密码加密
                inputpwd = accountService.getEntryptPassword(pwd, user.getSalt());//根据输入的原密码和数据库的盐，反推加密后的密码
                // 验证两个密码是否一致
                if (!oldPwd.equals(inputpwd)) {
                    json.put("resCode", "0");
                    json.put("resMsg", "原密码错误！");
                    return json.toJSONString();
                } else { //两个密码一致，就可以更新密码
                    user.setPlainPassword(newPwd);
                    user.setPassword(newPwd);
                    accountService.entryptPassword(user);  //对密码进行加密
                    //user.setPwd(Md5Util.toMD5(newPwd));
                    userService.updateUser(user);
                }
            }
            json.put("data", map);

//          // 修改密码
//          if (json.get("resCode").equals("1")) {
//              user.setPlainPassword(newPwd);
//              accountService.entryptPassword(user);  //对密码进行加密
//              //user.setPwd(Md5Util.toMD5(newPwd));
//              userService.updateUser(user);
//          }
        } catch (ServiceException e) {
            json.put("resCode", "0");
            json.put("resMsg", "服务器繁忙，请稍后再试！");
            logger.error("修改密码失败，错误为：" + e.getMessage());
        }
        return json.toJSONString();
    }

    /**
     * 验证手机验证码
     *
     * @param tel
     * @param valicode
     * @return
     */
    public boolean checkValidateCode(String tel, String valicode) {
        // 手机验证码
        String validate_code_server = (String) RedisClient.cacheGet(tel.concat("_code"));
//        // 获取万能验证码
//        String unisalCode = "";
//        UniversalCode universalCode = universalCodeService.getFirstUniversalCode();
//        if (universalCode != null && universalCode.getIsopen().equals("1")) {  //1代表开启
//            unisalCode = universalCode.getCode();
//        }
        logger.info("--tel:" + tel + ";---validate_code_server---:" + validate_code_server);
        //1.如果验证码和redis的不一致，开始比较万能验证码
//        if (!valicode.equals(validate_code_server)) {
//            //2.比较万能验证码
//            if (valicode.equals(unisalCode)) {
//                return true;
//            }
//            return false;
//        }
        return true;
    }


    /**
     * 用户登录，如果是欧曼的则给注册
     */
    public String checkOumanUser(String tel, String password) {
        // 这里调用欧曼的验证用户
        String oumanURL = PropUtil.getInstance().get("ouman.host") + "/manage/hs/getUser" + "?tel={0}&pwd={2}";
        String url = MessageFormat.format(oumanURL, tel, tel, password);
        JSONObject object = HttpTookit.Get(url, null);
        JSONObject json = new JSONObject();
        Map<String, Object> map = new HashMap<String, Object>();
        if (object != null && object.size() > 0) {
            String data = object.getString("data");
            if (StringUtils.isNotEmpty(data)) {
                logger.info("欧曼用户" + tel + "存在，现进行注册");
                User newUser = new User();
                newUser.setLoginName(tel);
                newUser.setName(tel);
                newUser.setPassword(password);
                newUser.setPlainPassword(password);
                newUser.setMobile(tel);
                newUser.setDeltag(EnumIsDelete.NOTDELETE.getCode());  // 默认是未删除
                accountService.entryptPassword(newUser);
                newUser.setType(EnumUserType.CUSTOMOR.getCode());  //标记是普通的用户类
                json.put("resCode", "1");
                json.put("resMsg", "登录成功");
                json.put("data", map);
                return json.toJSONString();
            } else {
                logger.info("欧曼用户不存在");
                return "1";
            }
        } else {
            logger.info("请求欧曼数据失败");
            return "1";
        }
    }
}
